package acm;

import java.util.ArrayList;
import testing.*;
import java.util.List;
import java.util.Scanner;

/**
 *
 */
public class FacilDeDecir {
	
	List<String> lista_letras = new ArrayList<String>();
	int largo_palabra;
	
	/**
	 * constructor vacio
	 */
	public FacilDeDecir(){
		
	}
    /**
     * @param palabra de tipo String que es validada segun las condiciones
     * @return un String validando si acepta o no la palabra
     */
    public String decir(String palabra) {
    	lista_letras = new ArrayList<String>();
    	
    	String resultado ="";
    	
    	dividir_palabra(palabra);
    	if(tieneVocales(palabra)==true && tiene2Consecutivas(palabra) == false && tiene3Consecutivas(palabra)==false){
    		resultado = "<"+palabra+"> is acceptable.";
    	}else{
    		resultado = "<"+palabra+"> is not acceptable.";
    	}
    	return resultado;
    }
    /**
     * @param palabra de tipo String que es validada segun la condicion.
     * @return true si la palabra contiene vocales, en su defecto false si es que no tiene vocales.
     */
    private boolean tieneVocales(String palabra){
    	int vocales = 0;
    	int largo_palabra = palabra.length();
    	
    	for(int cont = 0; cont<largo_palabra;cont++){
    		if(lista_letras.get(cont).equals("a") ||
    				lista_letras.get(cont).equals("e") ||
    				lista_letras.get(cont).equals("i") ||
    				lista_letras.get(cont).equals("o") ||
    				lista_letras.get(cont).equals("u")){
    			vocales++;
    		}
    	}
    	if(vocales == 0){
    		return false;
    	}else{
    		return true;
    	}
    }
    /**
     * @param palabra de tipo String que es validada segun la condicion.
     * @return true si tiene 2 ocurrencias consecutivas excepto si son 'ee' o 'oo', en su defecto, false si es que no tiene 2 ocurrencias.
     */
    private boolean tiene2Consecutivas(String palabra){
    	int consecutivas = 1;
    	String aux;
    	aux = lista_letras.get(0);
    			
    	for(int cont = 1; cont <largo_palabra; cont++){
    		if(aux.equals(lista_letras.get(cont))){
    			if(aux.equals("e") || aux.equals("o")){
    				
    			}else{
    				consecutivas++;
    				break;
    			}
    		}else{
    			aux = lista_letras.get(cont);
    			consecutivas = 1;
    		}
    	}
    	if(consecutivas >= 2){
    		return true;
    	}else{
    		return false;
    	}
    }
    /**
     * @param palabra de tipo String que es validada segun la condicion.
     * @return true si tiene 3 vocales o letras consecutivas, en su defecto false si no las tiene.
     */
    private boolean tiene3Consecutivas(String palabra){
    	int consecutivas = 1;
    	String aux;
    	aux = lista_letras.get(0);
    			
    	for(int cont = 1; cont <largo_palabra; cont++){
    		if(esVocal(aux)==true && esVocal(lista_letras.get(cont))==true){
    			consecutivas++;
    			if(consecutivas>=3){
    				break;
    			}
    		}else if(esVocal(aux)==false && esVocal(lista_letras.get(cont))==false){
    			consecutivas++;
    			if(consecutivas>=3){
    				break;
    			}
    		}else{
    			aux = lista_letras.get(cont);
    			consecutivas = 1;
    		}
    	}
    	if(consecutivas >= 2){
    		return true;
    	}else{
    		return false;
    	}
    }
    /**
     * @param letra la cual es validada segun el metodo
     * @return true si es que es una vocal, en su defecto false si es una consonante.
     */
    private boolean esVocal(String letra){
    	if(letra.equals("a") ||
    			letra.equals("e") ||
    			letra.equals("i") ||
    			letra.equals("o") ||
    			letra.equals("u")){
    		return true;
    	}else{
    		return false;
    	}
    }
    /**
     * @param palabra la cual es dividida por caracteres y almacenada en el objeto.
     */
    private void dividir_palabra(String palabra){

    	largo_palabra = palabra.length();
    	for(int cont = 0; cont<largo_palabra; cont++){
    		lista_letras.add(palabra.charAt(cont)+"");
    	}
    }
   
}
